package dbexp.utils;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.ArrayList;
import java.util.StringTokenizer;
import java.util.Vector;

/**
 * Narzędzie do wykonywania operacji na ciągach znakowych, tablicach oraz
 * listach
 */
public class StringUtil extends ObjectUtil {

	/**
	 * Prywatny kontruktor domyślny
	 */
	private StringUtil() {

	}

	/**
	 * Metoda dostępu do instancji
	 * 
	 * @return StringUtil
	 */
	public static StringUtil newInstanceStringUtil() {
		return new StringUtil();
	}

	/**
	 * Przekształca ciąg znakowy na tablice ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi przecinkiem
	 * 
	 * @return tablica ciągów znakowych
	 */
	public static String[] split(String string) {
		return split(string, false);
	}

	/**
	 * Przekształca ciąg znakowy na tablice ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi przecinkiem
	 * @param sort czy sortowac elementy
	 * 
	 * @return tablica ciągów znakowych
	 */
	public static String[] split(String string, boolean sort) {
		return split(string, Tool.nothing(), sort);
	}

	/**
	 * Przekształca ciąg znakowy na tablice ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi przecinkiem
	 * @param tools Narzędzie
	 * 
	 * @return tablica ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static String[] split(String string, Tool tools) {
		return split(string, false, tools);
	}

	/**
	 * Przekształca ciąg znakowy na tablice ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi przecinkiem
	 * @param tools tablica narzędzi
	 * 
	 * @return tablica ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static String[] split(String string, Tool[] tools) {
		return split(string, false, tools);
	}

	/**
	 * Przekształca ciąg znakowy na tablice ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi przecinkiem
	 * @param tools Narzędzie
	 * @param sort czy sortowac elementy
	 * 
	 * @return tablica ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static String[] split(String string, Tool tools, boolean sort) {
		return split(string, ",", tools, sort);
	}

	/**
	 * Przekształca ciąg znakowy na tablice ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi przecinkiem
	 * @param tools tablica narzędzi
	 * @param sort czy sortowac elementy
	 * 
	 * @return tablica ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static String[] split(String string, Tool[] tools, boolean sort) {
		return split(string, ",", tools, sort);
	}

	/**
	 * Przekształca ciąg znakowy na tablice ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi przecinkiem
	 * @param sort czy sortowac elementy
	 * @param tools Narzędzie
	 * 
	 * @return tablica ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static String[] split(String string, boolean sort, Tool tools) {
		return split(string, ",", sort, tools);
	}

	/**
	 * Przekształca ciąg znakowy na tablice ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi przecinkiem
	 * @param sort czy sortowac elementy
	 * @param tools tablica narzędzi
	 * 
	 * @return tablica ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static String[] split(String string, boolean sort, Tool[] tools) {
		return split(string, ",", sort, tools);
	}

	/**
	 * Przekształca ciąg znakowy na tablice ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi podanym znakiem/ciągiem
	 * @param regex znak/ciąg rozdzielający
	 * 
	 * @return tablica ciągów znakowych
	 */
	public static String[] split(String string, String regex) {
		return split(string, regex, new Tool[0], false);
	}

	/**
	 * Przekształca ciąg znakowy na tablice ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi podanym znakiem/ciągiem
	 * @param regex znak/ciąg rozdzielający
	 * @param sort czy sortowac elementy
	 * 
	 * @return tablica ciągów znakowych
	 */
	public static String[] split(String string, String regex, boolean sort) {
		return split(string, regex, new Tool[0], sort);
	}

	/**
	 * Przekształca ciąg znakowy na tablice ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi podanym znakiem/ciągiem
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param tools Narzędzie
	 * 
	 * @return tablica ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static String[] split(String string, String regex, Tool tools) {
		return split(string, regex, tools, false);
	}

	/**
	 * Przekształca ciąg znakowy na tablice ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi podanym znakiem/ciągiem
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param tools tablica narzędzi
	 * 
	 * @return tablica ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static String[] split(String string, String regex, Tool[] tools) {
		return split(string, regex, tools, false);
	}

	/**
	 * Przekształca ciąg znakowy na tablice ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi podanym znakiem/ciągiem
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param sort czy sortowac elementy
	 * @param tools Narzędzie
	 * 
	 * @return tablica ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static String[] split(String string, String regex, boolean sort,
			Tool tools) {
		if (tools != null) {
			return split(string, regex, sort, new Tool[] { tools });
		} else {
			return split(string, regex, sort, new Tool[0]);
		}
	}

	/**
	 * Przekształca ciąg znakowy na tablice ciągów znakowych
	 * 
		 * @param string ciąg z elementami rozdzielonymi podanym znakiem/ciągiem
		 * @param regex znak/ciąg rozdzieląjacy
		 * @param sort czy sortowac elementy
		 * @param tools tablica narzędzi
	 * 
	 * @return tablica ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static String[] split(String string, String regex, boolean sort,
			Tool[] tools) {
		String[] out = new String[] { string };
		if (string != null && string.trim().length() > 0 && regex != null) {
			StringTokenizer tok = new StringTokenizer(string, regex);
			out = new String[tok.countTokens()];
			int i = 0;
			while (tok.hasMoreTokens()) {
				out[i++] = tok.nextToken();
			}
			if (sort) {
				Arrays.sort(out);
			}
			for (int j = 0; j < out.length; j++) {
				Object cmo = invoke(out[j], tools, new Integer(j));
				if (!(cmo instanceof String)) {
					cmo = (cmo != null) ? cmo.toString() : cmo;
				}
				out[j] = (String) (cmo);
			}
		}
		return out;
	}

	/**
	 * Przekształca ciąg znakowy na tablice ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi podanym znakiem/ciągiem
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param tools Narzędzie
	 * @param sort czy sortowac elementy
	 * 
	 * @return tablica ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static String[] split(String string, String regex, Tool tools,
			boolean sort) {
		if (tools != null) {
			return split(string, regex, new Tool[] { tools }, sort);
		} else {
			return split(string, regex, new Tool[0], sort);
		}
	}

	/**
	 * Przekształca ciąg znakowy na tablice ciągów znakowych
	 * 
		 * @param string ciąg z elementami rozdzielonymi podanym znakiem/ciągiem
		 * @param regex znak/ciąg rozdzieląjacy
		 * @param tools tablica narzędzi
		 * @param sort czy sortowac elementy
	 * 
	 * @return tablica ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static String[] split(String string, String regex, Tool[] tools,
			boolean sort) {
		String[] out = new String[] { string };
		if (string != null && string.trim().length() > 0 && regex != null) {
			StringTokenizer tok = new StringTokenizer(string, regex);
			out = new String[tok.countTokens()];
			int i = 0;
			while (tok.hasMoreTokens()) {
				Object cmo = invoke(tok.nextToken(), tools, new Integer(i));
				if (!(cmo instanceof String)) {
					cmo = (cmo != null) ? cmo.toString() : cmo;
				}
				out[i++] = (String) (cmo);
			}
			if (sort) {
				Arrays.sort(out);
			}
		}
		return out;
	}

	/**
	 * Przekształca ciąg znakowy na listę ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi przecinkiem
	 * 
	 * @return lista ciągów znakowych
	 */
	public static List<String> getList(String string) {
		return getList(string, false);
	}

	/**
	 * Przekształca ciąg znakowy na wektor ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi przecinkiem
	 * @return wektor ciągów znakowych
	 * @deprecated użyj {@link #getList(String)}
	 */
	public static Vector<String> getVector(String string) {
		return new Vector<String>(getList(string, false));
	}

	/**
	 * Przekształca ciąg znakowy na liste ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi przecinkiem
	 * @param sort czy sortowac elementy
	 * 
	 * @return lista ciągów znakowych
	 */
	public static List<String> getList(String string, boolean sort) {
		return getList(string, ",", new Tool[0], sort);
	}

	/**
	 * Przekształca ciąg znakowy na liste ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi przecinkiem
	 * @param tools Narzędzie
	 * 
	 * @return lista ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static List<String> getList(String string, Tool tools) {
		return getList(string, ",", false, tools);
	}

	/**
	 * Przekształca ciąg znakowy na wektor ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi przecinkiem
	 * @param tools Narzędzie
	 * 
	 * @return wektor ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 * @deprecated użyj {@link #getList(String, Tool)}
	 */
	public static Vector<String> getVector(String string, Tool tools) {
		return new Vector<String>(getList(string, ",", false, tools));
	}

	/**
	 * Przekształca ciąg znakowy na liste ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi przecinkiem
	 * @param tools tablica narzędzi
	 * 
	 * @return lista ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static List<String> getList(String string, Tool[] tools) {
		return getList(string, ",", false, tools);
	}

	/**
	 * Przekształca ciąg znakowy na liste ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi przecinkiem
	 * @param tools Narzędzie
	 * @param sort czy sortowac elementy
	 * 
	 * @return lista ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static List<String> getList(String string, Tool tools, boolean sort) {
		return getList(string, ",", tools, sort);
	}

	/**
	 * Przekształca ciąg znakowy na liste ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi przecinkiem
	 * @param tools tablica narzędzi
	 * @param sort czy sortowac elementy
	 * 
	 * @return lista ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static List<String> getList(String string, Tool[] tools, boolean sort) {
		return getList(string, ",", tools, sort);
	}

	/**
	 * Przekształca ciąg znakowy na liste ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi przecinkiem
	 * @param sort czy sortowac elementy
	 * @param tools Narzędzie
	 * 
	 * @return lista ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static List<String> getList(String string, boolean sort, Tool tools) {
		return getList(string, ",", sort, tools);
	}

	/**
	 * Przekształca ciąg znakowy na liste ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi przecinkiem
	 * @param sort czy sortowac elementy
	 * @param tools tablica narzędzi
	 * 
	 * @return lista ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static List<String> getList(String string, boolean sort, Tool[] tools) {
		return getList(string, ",", sort, tools);
	}

	/**
	 * Przekształca ciąg znakowy na liste ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi podanym znakiem/ciągiem
	 * @param regex znak/ciąg rozdzieląjacy
	 * 
	 * @return lista ciągów znakowych
	 */
	public static List<String> getList(String string, String regex) {
		return getList(string, regex, new Tool[0], false);
	}

	/**
	 * Przekształca ciąg znakowy na wektor ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi podanym znakiem/ciągiem
	 * @param regex znak/ciąg rozdzieląjacy
	 * 
	 * @return wektor ciągów znakowych
	 * @deprecated użyj {@link #getList(String, String)}
	 */
	public static Vector<String> getVector(String string, String regex) {
		return new Vector<String>(getList(string, regex, new Tool[0], false));
	}

	/**
	 * Przekształca ciąg znakowy na liste ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi podanym znakiem/ciągiem
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param sort czy sortowac elementy
	 * 
	 * @return lista ciągów znakowych
	 */
	public static List<String> getList(String string, String regex, boolean sort) {
		return getList(string, regex, new Tool[0], sort);
	}

	/**
	 * Przekształca ciąg znakowy na liste ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi podanym znakiem/ciągiem
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param tools Narzędzie
	 * 
	 * @return lista ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static List<String> getList(String string, String regex, Tool tools) {
		return getList(string, regex, tools, false);
	}

	/**
	 * Przekształca ciąg znakowy na liste ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi podanym znakiem/ciągiem
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param tools tablica narzędzi
	 * 
	 * @return lista ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static List<String> getList(String string, String regex, Tool[] tools) {
		return getList(string, regex, tools, false);
	}

	/**
	 * Przekształca ciąg znakowy na liste ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi podanym znakiem/ciągiem
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param sort czy sortowac elementy
	 * @param tools Narzędzie
	 * 
	 * @return lista ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static List<String> getList(String string, String regex, boolean sort,
			Tool tools) {
		if (tools != null) {
			return getList(string, regex, sort, new Tool[] { tools });
		} else {
			return getList(string, regex, sort, new Tool[0]);
		}
	}

	/**
	 * Przekształca ciąg znakowy na liste ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi podanym znakiem/ciągiem
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param sort czy sortowac elementy
	 * @param tools tablica narzędzi
	 * 
	 * @return lista ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static List<String> getList(String string, String regex, boolean sort,
			Tool[] tools) {
		List<String> out = new ArrayList<String>();
		String[] array = split(string, regex, sort, tools);
		for (int i = 0; i < array.length; i++) {
			out.add(i, array[i]);
		}
		return out;
	}

	/**
	 * Przekształca ciąg znakowy na liste ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi podanym znakiem/ciągiem
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param tools Narzędzie
	 * @param sort czy sortowac elementy
	 * 
	 * @return lista ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static List<String> getList(String string, String regex, Tool tools,
			boolean sort) {
		if (tools != null) {
			return getList(string, regex, new Tool[] { tools }, sort);
		} else {
			return getList(string, regex, new Tool[0], sort);
		}
	}

	/**
	 * Przekształca ciąg znakowy na liste ciągów znakowych
	 * 
	 * @param string ciąg z elementami rozdzielonymi podanym znakiem/ciągiem
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param tools tablica narzędzi
	 * @param sort czy sortowac elementy
	 * 
	 * @return lista ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static List<String> getList(String string, String regex, Tool[] tools,
			boolean sort) {
		List<String> out = new ArrayList<String>();
		String[] array = split(string, regex, tools, sort);
		for (int i = 0; i < array.length; i++) {
			out.add(i, array[i]);
		}
		return out;
	}

	/**
	 * Przekształca tablice ciągów znakowych na liste ciągów znakowych
	 * 
	 * @param array tablica ciągów znakowych
	 * 
	 * @return lista ciągów znakowych
	 */
	public static List<String> getList(String[] array) {
		return getList(array, false);
	}

	/**
	 * Przekształca tablice ciągów znakowych na wektor ciągów znakowych
	 * 
	 * @param array tablica ciągów znakowych
	 * 
	 * @return wektor ciągów znakowych
	 * 
	 * @deprecated użyj {@link #getList(String[])}
	 */
	public static Vector<String> getVector(String[] array) {
		return new Vector<String>(getList(array, false));
	}

	/**
	 * Przekształca tablice ciągów znakowych na liste ciągów znakowych
	 * 
	 * @param array tablica ciągów znakowych
	 * @param sort czy sortowac elementy
	 * 
	 * @return lista ciągów znakowych
	 */
	public static List<String> getList(String[] array, boolean sort) {
		return getList(array, new Tool[0], sort);
	}

	/**
	 * Przekształca tablice ciągów znakowych na liste ciągów znakowych
	 * 
	 * @param array tablica ciągów znakowych
	 * @param tools Narzędzie
	 * 
	 * @return lista ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static List<String> getList(String[] array, Tool tools) {
		return getList(array, false, tools);
	}

	/**
	 * Przekształca tablice ciągów znakowych na liste ciągów znakowych
	 * 
	 * @param array tablica ciągów znakowych
	 * @param tools tablica narzędzi
	 * 
	 * @return lista ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static List<String> getList(String[] array, Tool[] tools) {
		return getList(array, false, tools);
	}

	/**
	 * Przekształca tablice ciągów znakowych na liste ciągów znakowych
	 * 
	 * @param array tablica ciągów znakowych
	 * @param sort czy sortowac elementy
	 * @param tools Narzędzie
	 * 
	 * @return lista ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static List<String> getList(String[] array, boolean sort, Tool tools) {
		if (tools != null) {
			return getList(array, sort, new Tool[] { tools });
		} else {
			return getList(array, sort, new Tool[0]);
		}
	}

	/**
	 * Przekształca tablice ciągów znakowych na liste ciągów znakowych
	 * 
	 * @param array tablica ciągów znakowych
	 * @param sort czy sortowac elementy
	 * @param tools tablica narzędzi
	 * 
	 * @return lista ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static List<String> getList(String[] array, boolean sort, Tool[] tools) {
		List<String> out = new ArrayList<String>();
		if (array != null && array.length > 0) {
			if (sort) {
				Arrays.sort(array);
			}
			for (int i = 0; i < array.length; i++) {
				out.add(i, (String) invoke(array[i], tools, new Integer(i)));
			}
		}
		return out;
	}

	/**
	 * Przekształca tablice ciągów znakowych na liste ciągów znakowych
	 * 
	 * @param array tablica ciągów znakowych
	 * @param tools Narzędzie
	 * @param sort czy sortowac elementy
	 * 
	 * @return lista ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static List<String> getList(String[] array, Tool tools, boolean sort) {
		if (tools != null) {
			return getList(array, new Tool[] { tools }, sort);
		} else {
			return getList(array, new Tool[] {}, sort);
		}
	}

	/**
	 * Przekształca tablice ciągów znakowych na liste ciągów znakowych
	 * 
	 * @param array tablica ciągów znakowych
	 * @param tools tablica narzędzi
	 * @param sort czy sortowac elementy
	 * 
	 * @return lista ciągów znakowych
	 * @see parasoft.centrap.utils.Tool
	 */
	public static List<String> getList(String[] array, Tool[] tools, boolean sort) {
		List<String> out = new ArrayList<String>();
		if (array != null && array.length > 0) {
			Object[] tmp = new Object[array.length];
			for (int i = 0; i < array.length; i++) {
				Object cmo = (invoke(array[i], tools, new Integer(i)));
				if (!(cmo instanceof String)) {
					cmo = (cmo != null) ? cmo.toString() : cmo;
				}
				tmp[i] = (cmo);
			}
			if (sort) {
				Arrays.sort(tmp);
			}
			for (int i = 0; i < tmp.length; i++) {
				out.add(i, (String) tmp[i]);
			}
		}
		return out;
	}

	/**
	 * Łączy elementy tablicy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi przecinkiem
	 * 
	 * @param array tablica ciągów znakowych
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 */
	public static String join(Object[] array) {
		return join(array, false);
	}

	/**
	 * Łączy elementy tablicy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi przecinkiem
	 * 
	 * @param array tablica ciągów znakowych
	 * @param sort czy sortowac elementy
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 */
	public static String join(Object[] array, boolean sort) {
		return join(array, ",", new Tool[0], sort);
	}

	/**
	 * Łączy elementy tablicy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi przecinkiem
	 * 
	 * @param array tablica ciągów znakowych
	 * @param tools Narzędzie
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.Tool
	 */
	public static String join(Object[] array, Tool tools) {
		return join(array, ",", false, tools);
	}

	/**
	 * Łączy elementy tablicy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi przecinkiem
	 * 
	 * @param array tablica ciągów znakowych
	 * @param tools tablica narzędzi
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.Tool
	 */
	public static String join(Object[] array, Tool[] tools) {
		return join(array, ",", false, tools);
	}

	/**
	 * Łączy elementy tablicy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi przecinkiem
	 * 
	 * @param array tablica ciągów znakowych
	 * @param sort czy sortowac elementy
	 * @param tools Narzędzie
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.Tool
	 */
	public static String join(Object[] array, boolean sort, Tool tools) {
		return join(array, ",", sort, tools);
	}

	/**
	 * Łączy elementy tablicy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi przecinkiem
	 * 
	 * @param array tablica ciągów znakowych
	 * @param sort czy sortowac elementy
	 * @param tools tablica narzędzi
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.Tool
	 */
	public static String join(Object[] array, boolean sort, Tool[] tools) {
		return join(array, ",", sort, tools);
	}

	/**
	 * Łączy elementy tablicy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi przecinkiem
	 * 
	 * @param array tablica ciągów znakowych
	 * @param tools Narzędzie
	 * @param sort czy sortowac elementy
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.Tool
	 */
	public static String join(Object[] array, Tool tools, boolean sort) {
		return join(array, ",", tools, sort);
	}

	/**
	 * Łączy elementy tablicy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi przecinkiem
	 * 
	 * @param array tablica ciągów znakowych
	 * @param tools tablica narzędzi
	 * @param sort czy sortowac elementy
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.Tool
	 */
	public static String join(Object[] array, Tool[] tools, boolean sort) {
		return join(array, ",", tools, sort);
	}

	/**
	 * Łączy elementy tablicy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi ustawionym znakiem/ciągiem
	 * 
	 * @param array tablica ciągów znakowych
	 * @param regex znak/ciąg rozdzieląjacy
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 */
	public static String join(Object[] array, String regex) {
		return join(array, regex, new Tool[0], false);
	}

	/**
	 * Łączy elementy tablicy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi ustawionym znakiem/ciągiem
	 * 
	 * @param array tablica ciągów znakowych
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param sort czy sortowac elementy
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 */
	public static String join(Object[] array, String regex, boolean sort) {
		return join(array, regex, new Tool[0], sort);
	}

	/**
	 * Łączy elementy tablicy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi ustawionym znakiem/ciągiem
	 * 
	 * @param array tablica ciągów znakowych
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param tools Narzędzie
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.Tool
	 */
	public static String join(Object[] array, String regex, Tool tools) {
		return join(array, regex, false, tools);
	}

	/**
	 * Łączy elementy tablicy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi ustawionym znakiem/ciągiem
	 * 
	 * @param array tablica ciągów znakowych
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param tools tablica narzędzi
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.Tool
	 */
	public static String join(Object[] array, String regex, Tool[] tools) {
		return join(array, regex, false, tools);
	}

	/**
	 * Łączy elementy tablicy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi ustawionym znakiem/ciągiem
	 * 
	 * @param array tablica ciągów znakowych
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param sort czy sortowac elementy
	 * @param tools Narzędzie
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.Tool
	 */
	public static String join(Object[] array, String regex, boolean sort,
			Tool tools) {
		if (tools != null) {
			return join(array, regex, sort, new Tool[] { tools });
		} else {
			return join(array, regex, sort, new Tool[0]);
		}
	}

	/**
	 * Łączy elementy tablicy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi ustawionym znakiem/ciągiem
	 * 
	 * @param array tablica ciągów znakowych
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param sort czy sortowac elementy
	 * @param tools tablica narzędzi
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.Tool
	 */
	public static String join(Object[] array, String regex, boolean sort,
			Tool[] tools) {
		StringBuffer out = new StringBuffer("");
		if (array != null && array.length > 0) {
			if (sort) {
				Arrays.sort(array);
			}
			for (int i = 0; i <= array.length - 2; i++) {
				out.append(invoke(array[i], tools, new Integer(i)));
				out.append(regex);
			}
			out.append(invoke(array[array.length - 1], tools, new Integer(
					array.length - 1)));
		}
		return out.toString();
	}

	/**
	 * Łączy elementy tablicy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi ustawionym znakiem/ciągiem
	 * 
	 * @param array tablica ciągów znakowych
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param tools Narzędzie
	 * @param sort czy sortowac elementy
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.Tool
	 */
	public static String join(Object[] array, String regex, Tool tools,
			boolean sort) {
		if (tools != null) {
			return join(array, regex, new Tool[] { tools }, sort);
		} else {
			return join(array, regex, new Tool[] {}, sort);
		}
	}

	/**
	 * Łączy elementy tablicy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi ustawionym znakiem/ciągiem
	 * 
	 * @param array tablica ciągów znakowych
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param tools tablica narzędzi
	 * @param sort czy sortowac elementy
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.Tool
	 */
	public static String join(Object[] array, String regex, Tool[] tools,
			boolean sort) {
		StringBuffer out = new StringBuffer("");
		if (array != null && array.length > 0) {
			Object[] tmp = new Object[array.length];
			for (int i = 0; i < array.length; i++) {
				Object cmo = invoke(array[i], tools, new Integer(i));
				if (!(cmo instanceof String)) {
					cmo = (cmo != null) ? cmo.toString() : cmo;
				}
				tmp[i] = (cmo);
			}
			if (sort) {
				Arrays.sort(tmp);
			}
			for (int i = 0; i <= tmp.length - 2; i++) {
				out.append(tmp[i]);
				out.append(regex);
			}
			out.append(tmp[array.length - 1]);
		}
		return out.toString();
	}

	/**
	 * Łączy elementy listy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi przecinkiem
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @deprecated use {@link #join(List)}
	 */
	public static String getString(List<String> in) {
		return join(in, false);
	}
	
	/**
	 * Łączy elementy listy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi ustawionym znakiem/ciągiem
	 * 
	 * @param regex znak/ciąg rozdzieląjacy
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.StringUtil#join(List, String, Tool[],
	 *      boolean)
	 * @deprecated use {@link #join(List, String)}
	 */
	public static String getString(List<String> in, String regex) {
		return join(in, regex, new Tool[0], false);
	}

	/**
	 * Łączy elementy listy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi przecinkiem
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.StringUtil#join(List, boolean)
	 */
	public static String join(List<String> in) {
		return join(in, false);
	}

	/**
	 * Łączy elementy listy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi przecinkiem
	 * 
	 * @param sort czy sortowac elementy
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.StringUtil#join(List, String, Tool[],
	 *      boolean)
	 */
	public static String join(List<String> in, boolean sort) {
		return join(in, ",", new Tool[0], sort);
	}

	/**
	 * Łączy elementy listy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi przecinkiem
	 * 
	 * @param tools Narzędzie
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.Tool
	 * @see parasoft.centrap.utils.StringUtil#join(List, String, boolean,
	 *      Tool[])
	 */
	public static String join(List<String> in, Tool tools) {
		return join(in, ",", false, new Tool[] { tools });
	}

	/**
	 * Łączy elementy listy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi przecinkiem
	 * 
	 * @param tools tablica narzędzi
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.Tool
	 * @see parasoft.centrap.utils.StringUtil#join(List, String, boolean,
	 *      Tool[])
	 */
	public static String join(List<String> in, Tool[] tools) {
		return join(in, ",", false, tools);
	}

	/**
	 * Łączy elementy listy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi przecinkiem
	 * 
	 * @param tools tablica narzędzi
	 * @param sort czy sortowac elementy
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.Tool
	 * @see parasoft.centrap.utils.StringUtil#join(List, String, Tool[],
	 *      boolean)
	 */
	public static String join(List<String> in, Tool[] tools, boolean sort) {
		return join(in, ",", tools, sort);
	}

	/**
	 * Łączy elementy listy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi przecinkiem
	 * 
	 * @param tools Narzędzie
	 * @param sort czy sortowac elementy
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.Tool
	 * @see parasoft.centrap.utils.StringUtil#join(List, String, Tool[],
	 *      boolean)
	 */
	public static String join(List<String> in, Tool tools, boolean sort) {
		return join(in, ",", tools, sort);
	}

	/**
	 * Łączy elementy listy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi przecinkiem
	 * 
	 * @param sort czy sortowac elementy
	 * @param tools tablica narzędzi
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.Tool
	 * @see parasoft.centrap.utils.StringUtil#join(List, String, boolean,
	 *      Tool[])
	 */
	public static String join(List<String> in, boolean sort, Tool[] tools) {
		return join(in, ",", sort, tools);
	}

	/**
	 * Łączy elementy listy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi ustawionym znakiem/ciągiem
	 * 
	 * @param regex znak/ciąg rozdzieląjacy
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.StringUtil#join(List, String, Tool[],
	 *      boolean)
	 */
	public static String join(List<String> in, String regex) {
		return join(in, regex, new Tool[0], false);
	}

	/**
	 * Łączy elementy listy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi ustawionym znakiem/ciągiem
	 * 
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param sort czy sortowac elementy
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.StringUtil#join(List, String, Tool[],
	 *      boolean)
	 */
	public static String join(List<String> in, String regex, boolean sort) {
		return join(in, regex, new Tool[0], sort);
	}

	/**
	 * Łączy elementy listy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi ustawionym znakiem/ciągiem
	 * 
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param tools Narzędzie
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.Tool
	 * @see parasoft.centrap.utils.StringUtil#join(List, String, boolean,
	 *      Tool[])
	 */
	public static String join(List<String> in, String regex, Tool tools) {
		return join(in, regex, false, tools);
	}

	/**
	 * Łączy elementy listy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi ustawionym znakiem/ciągiem
	 * 
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param tools tablica narzędzi
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.Tool
	 * @see parasoft.centrap.utils.StringUtil#join(List, String, boolean,
	 *      Tool[])
	 */
	public static String join(List<String> in, String regex, Tool[] tools) {
		return join(in, regex, false, tools);
	}

	/**
	 * Łączy elementy listy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi ustawionym znakiem/ciągiem
	 * 
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param sort czy sortowac elementy
	 * @param tools Narzędzie
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.Tool
	 * @see parasoft.centrap.utils.StringUtil#join(List, String, boolean,
	 *      Tool[])
	 */
	public static String join(List<String> in, String regex, boolean sort, Tool tools) {
		return join(in, regex, sort, new Tool[] { tools });
	}

	/**
	 * Łączy elementy listy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi ustawionym znakiem/ciągiem
	 * 
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param sort czy sortowac elementy
	 * @param tools tablica narzędzi
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.Tool
	 * @see parasoft.centrap.utils.StringUtil#join(List, String, boolean,
	 *      Tool[])
	 */
	public static String join(List<String> in, String regex, boolean sort,
			Tool[] tools) {
		Object[] array = null;
		if (in != null && in.size() > 0) {
			array = in.toArray();
		}
		return join(array, regex, sort, tools);
	}

	/**
	 * Łączy elementy listy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi ustawionym znakiem/ciągiem
	 * 
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param tools Narzędzie
	 * @param sort czy sortowac elementy
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.Tool
	 * @see parasoft.centrap.utils.StringUtil#join(List, String, Tool[],
	 *      boolean)
	 */
	public static String join(List<String> in, String regex, Tool tools, boolean sort) {
		return join(in, regex, new Tool[] { tools }, sort);
	}

	/**
	 * Łączy elementy listy ciągów znakowych w jeden ciąg z elementami
	 * rozdzielonymi ustawionym znakiem/ciągiem
	 * 
	 * @param regex znak/ciąg rozdzieląjacy
	 * @param tools tablica narzędzi
	 * @param sort czy sortowac elementy
	 * 
	 * @return ciąg znakowy z elementami rozdzielonymi przecinkiem
	 * @see parasoft.centrap.utils.Tool
	 * @see parasoft.centrap.utils.StringUtil#join(List, String, Tool[],
	 *      boolean)
	 */
	public static String join(List<String> in, String regex, Tool[] tools,
			boolean sort) {
		Object[] array = null;
		if (in != null && in.size() > 0) {
			array = new Object[in.size()];
			array = in.toArray();
		}
		return join(array, regex, tools, sort);
	}

	/**
	 * Zwraca aktualna date w postaci Stringa
	 * 
	 * @return date w formacie ddMMyyyy, np.:30122008
	 * @see parasoft.centrap.utils.StringUtil#getDate(String, long)
	 */
	public static String getDate() {
		return getDate("ddMMyyyy", new Date().getTime());
	}

	/**
	 ** Zwraca aktualna date w postaci Stringa
	 * 
	 * @return date w formacie podanym jako parametr
	 * @see parasoft.centrap.utils.StringUtil#getDate(String, long)
	 */
	public static String getDate(String format) {
		return getDate(format, new Date().getTime());
	}

/**
	 * Zwraca date w postaci Stringa na podstawie podanego czasu z milisekundach
	 * <blockquote>
	 * <table border=0 cellspacing=3 cellpadding=0 summary="Chart shows pattern letters, date/time component, presentation, and examples.">
	 *     <tr bgcolor="#ccccff">
	 *         <th align=left>Letter
	 *         <th align=left>Date or Time Component
	 *         <th align=left>Presentation
	 *         <th align=left>Examples
	 *         <tr>
	 *         <td><code>dd-MM-yyyy kk:mm:ss:SSS</code>
	 *         <td>Full date
	 *         <td><a href="#text">Text</a>
	 *         <td><code>30-12-2009 11:57:10:101</code>
	 *     <tr>
	 *         <td><code>G</code>
	 *         <td>Era designator
	 *         <td><a href="#text">Text</a>
	 *         <td><code>AD</code>
	 *     <tr bgcolor="#eeeeff">
	 *         <td><code>y</code>
	 *         <td>Year
	 *         <td><a href="#year">Year</a>
	 *         <td><code>1996</code>; <code>96</code>
	 *     <tr>
	 *         <td><code>M</code>
	 *         <td>Month in year
	 *         <td><a href="#month">Month</a>
	 *         <td><code>July</code>; <code>Jul</code>; <code>07</code>
	 *     <tr bgcolor="#eeeeff">
	 *         <td><code>w</code>
	 *         <td>Week in year
	 *         <td><a href="#number">Number</a>
	 *         <td><code>27</code>
	 *     <tr>
	 *         <td><code>W</code>
	 *         <td>Week in month
	 *         <td><a href="#number">Number</a>
	 *         <td><code>2</code>
	 *     <tr bgcolor="#eeeeff">
	 *         <td><code>D</code>
	 *         <td>Day in year
	 *         <td><a href="#number">Number</a>
	 *         <td><code>189</code>
	 *     <tr>
	 *         <td><code>d</code>
	 *         <td>Day in month
	 *         <td><a href="#number">Number</a>
	 *         <td><code>10</code>
	 *     <tr bgcolor="#eeeeff">
	 *         <td><code>F</code>
	 *         <td>Day of week in month
	 *         <td><a href="#number">Number</a>
	 *         <td><code>2</code>
	 *     <tr>
	 *         <td><code>E</code>
	 *         <td>Day in week
	 *         <td><a href="#text">Text</a>
	 *         <td><code>Tuesday</code>; <code>Tue</code>
	 *     <tr bgcolor="#eeeeff">
	 *         <td><code>a</code>
	 *         <td>Am/pm marker
	 *         <td><a href="#text">Text</a>
	 *         <td><code>PM</code>
	 *     <tr>
	 *         <td><code>H</code>
	 *         <td>Hour in day (0-23)
	 *         <td><a href="#number">Number</a>
	 *         <td><code>0</code>
	 *     <tr bgcolor="#eeeeff">
	 *         <td><code>k</code>
	 *         <td>Hour in day (1-24)
	 *         <td><a href="#number">Number</a>
	 *         <td><code>24</code>
	 *     <tr>
	 *         <td><code>K</code>
	 *         <td>Hour in am/pm (0-11)
	 *         <td><a href="#number">Number</a>
	 *         <td><code>0</code>
	 *     <tr bgcolor="#eeeeff">
	 *         <td><code>h</code>
	 *         <td>Hour in am/pm (1-12)
	 *         <td><a href="#number">Number</a>
	 *         <td><code>12</code>
	 *     <tr>
	 *         <td><code>m</code>
	 *         <td>Minute in hour
	 *         <td><a href="#number">Number</a>
	 *         <td><code>30</code>
	 *     <tr bgcolor="#eeeeff">
	 *         <td><code>s</code>
	 *         <td>Second in minute
	 *         <td><a href="#number">Number</a>
	 *         <td><code>55</code>
	 *     <tr>
	 *         <td><code>S</code>
	 *         <td>Millisecond
	 *         <td><a href="#number">Number</a>
	 *         <td><code>978</code>
	 *     <tr bgcolor="#eeeeff">
	 *         <td><code>z</code>
	 *         <td>Time zone
	 *         <td><a href="#timezone">General time zone</a>
	 *         <td><code>Pacific Standard Time</code>; <code>PST</code>; <code>GMT-08:00</code>
	 *     <tr>
	 *         <td><code>Z</code>
	 *         <td>Time zone
	 *         <td><a href="#rfc822timezone">RFC 822 time zone</a>
	 *         <td><code>-0800</code>
	 * </table>
	 * </blockquote>
	 *
	 * @param format for example.: ddMMyyyy kk:mm:ss:SSS
	 * @param time milisekundy
	 * @see java.util.Date#Date()
	 * @see java.util.Date#setTime(long)
	 * @see java.text.DateFormat
	 * @see java.text.SimpleDateFormat#SimpleDateFormat(String format)
	 * @see java.text.SimpleDateFormat#format(Date)
	 *
	 * @return ciąg znakow reprezentujacych date
	 */
	public static String getDate(String format, long time) {
		Date now = new Date();
		now.setTime(time);
		DateFormat fmt = new SimpleDateFormat(format);
		String snow = fmt.format(now);
		return snow;
	}

	/**
	 * Zwraca czas w milisekundach z aktualnej daty
	 * 
	 * @see parasoft.centrap.utils.StringUtil#getDate()
	 * @return milisekundy z daty w postaci ciagu znakowego, okreslajacego
	 *         dzisiejsza date
	 */
	public static long getTime() {
		return getTime(getDate());
	}

	/**
	 * Zwraca czas w milisekundach z daty podanej jako parametr
	 * 
	 * @param date data w postaci ciagu znakowego, wymagany format dd-MM-yyyy
	 * @see parasoft.centrap.utils.StringUtil#getTime(String, String)
	 * @return milisekundy
	 */
	public static long getTime(String date) {
		return getTime(date, "dd-MM-yyyy");
	}

	/**
	 * Zwraca czas w milisekundach z daty podanej jako parametr
	 * 
	 * @param date data w postaci ciagu znakowego
	 * @param format format w jakim jest przekazana data
	 * @return milisekundy
	 */
	public static long getTime(String date, String format) {
		try {
			return new SimpleDateFormat(format).parse(date).getTime();
		} catch (ParseException e) {
			return new Date().getTime();
		}
	}
	
	public static int count(String in, String regex){
		return (" "+in+" ").split(regex).length-1;
	}

	/**
	 * Wyciąga liczbę z napisu
	 * 
	 * @param liczba wejście
	 * @return String
	 */
	public static String valid(String liczba) {
		String out = liczba;
		if (liczba != null && liczba.trim().length() > 0
				&& (liczba.indexOf(",") != -1 || liczba.indexOf(".") != -1)) {
			String[] liczby = liczba.replaceAll("[.]", ",").split("[,.]");
			String sZlote = liczby[0].replaceAll("\\W", "");
			String sGrosze = liczby[1].replaceAll("\\W", "");
			int zlote = Integer.parseInt(sZlote);
			int grosze = Integer.parseInt(sGrosze);
			int realGroszy = grosze % 100;// grosze
			int dodZlote = grosze / 100;// zlote
			out = String.valueOf(zlote + dodZlote) + ","
					+ String.valueOf(realGroszy);
		} else {
			out = liczba.replaceAll("\\W", "_");
		}
		return out;
	}

	/**
	 * Konwertuje ciąg znakowy na reprezantacje obiektową
	 * 
	 * @param s ciąg znakowy
	 *
	 * @return obiekt
	 * @since centrala-2_39
	 */
	public static Object stringToValue(String s) {
		if (s.equals("")) {
			return s;
		}
		if (s.equalsIgnoreCase("true")) {
			return Boolean.TRUE;
		}
		if (s.equalsIgnoreCase("false")) {
			return Boolean.FALSE;
		}
		if (s.equalsIgnoreCase("null")) {
			return null;
		}

		char b = s.charAt(0);
		if ((b >= '0' && b <= '9') || b == '.' || b == '-' || b == '+') {
			if (b == '0') {
				if (s.length() > 2
						&& (s.charAt(1) == 'x' || s.charAt(1) == 'X')) {
					try {
						return new Integer(Integer.parseInt(s.substring(2), 16));
					} catch (Exception e) {
						/* Ignore the error */
					}
				} else {
					try {
						return new Integer(Integer.parseInt(s, 8));
					} catch (Exception e) {
						/* Ignore the error */
					}
				}
			}
			try {
				if (s.indexOf('.') > -1 || s.indexOf('e') > -1
						|| s.indexOf('E') > -1) {
					return Double.valueOf(s);
				} else {
					Long myLong = new Long(s);
					if (myLong.longValue() == myLong.intValue()) {
						return new Integer(myLong.intValue());
					} else {
						return myLong;
					}
				}
			} catch (Exception f) {
				/* Ignore the error */
			}
		}
		return s;
	}
}
